import { checkAllCart, deleteCart, findCart, getNewCartGoods, insertCart, mergeCart, updateCart } from '@/api/cart'

//  购物车状态
const state = {
  list: []
}

// 修改 state 的函数
const mutations = {
  // 加入购物车
  insertCart (state, payload) {
    // 考虑两种情况：
    //  情况1：已经添加过的商品(skuid已存在)，是数量的累加
    //  情况2：没有添加过的就添加到列表前
    const index = state.list.findIndex(item => item.skuId === payload.skuId)
    if (index >= 0) {
      state.list[index].count += payload.count
    } else {
      state.list.unshift(payload)
    }
  },
  // 删除购物车商品
  deleteCart (state, skuId) {
    const index = state.list.findIndex(item => item.skuId === skuId)
    state.list.splice(index, 1)
  },
  // 更新修改购物车商品对象
  updateCart (state, goods) {
    const obj = state.list.find(item => item.skuId === goods.skuId)
    for (const key in goods) {
      if (goods[key] !== null) {
        obj[key] = goods[key]
      }
    }
  },
  // 设置购物车列表（这里主要是赋值操作，赋值空数组就清空购物车列表，也可赋值最新购物车列表数据）
  setCartList (state, payload) {
    state.list = payload
  }
}

const getters = {
  // 有效商品列表
  validList (state) {
    // 商品有效 并且 有库存
    return state.list.filter(item => item.isEffective && item.stock > 0)
  },
  // 有效商品件数
  validTotal (state, getters) {
    // 淘宝利用商品种类计算方式
    return getters.validList.length
  },
  validCountTotal (state, getters) {
    // 计算总数量
    // 方法1
    //   let count = 0
    //   getters.validList.forEach(item => {
    //     count += item.count
    //   })
    //   return count

    return getters.validList.reduce((count, item) => count + item.count, 0)
  },
  // 有效商品总金额
  validAmount (state, getters) {
    // JS 小数的计算会容易出现精度不准的问题，解决方案：把小数先放大处理成整数，计算完毕后，再除以倍数变回小数
    return (
      getters.validList.reduce(
        (total, item) => total + item.price * item.count * 100,
        0
      ) / 100
    )
  },
  // 无效商品列表
  invalidList (state) {
    return state.list.filter(item => !item.isEffective || item.stock === 0)
  },

  // 🔔选中系列
  // 选中商品列表
  selectedList (state, getters) {
    return getters.validList.filter(item => item.selected)
  },
  // 选中商品件数
  selectedTotal (state, getters) {
    return getters.selectedList.reduce((total, item) => total + item.count, 0)
  },
  // 选中商品总金额
  selectedAmount (state, getters) {
    return (
      getters.selectedList.reduce(
        (amount, item) => amount + item.count * item.price * 100,
        0
      ) / 100
    )
  },
  // 是否全选
  isCheckAll (state, getters) {
    return (
      getters.selectedList.length === getters.validList.length &&
      getters.validList.length !== 0
    )
  }
}

// 做异步操作的函数
const actions = {
  // 加入购物车
  //  store.rootState 可以访问到整个大的 state，跨模块访问数据
  insertCart (store, payload) {
    // console.log(store)

    // 包装成 Promise 对象，在调用 dispatch 后可通过 then
    return new Promise(resolve => {
      // 分两种情况:
      if (store.rootState.user.profile.token) {
        // 1. 已登录 - 发送请求

        // 方法1
        // 发送第一个请求，把商品添加到服务器中
        // insertCart({ skuId: payload.skuId, count: payload.count }).then(res => {
        //   console.log(res)
        //   // 还需要发第二个请求，获取最新服务器的购物车列表
        //   store.dispatch('findCartList')

        //   resolve('加入购物车成功')
        // })

        // 方法2
        insertCart({ skuId: payload.skuId, count: payload.count }).then(() => {
          return findCart()
        }).then(({ result }) => {
          store.commit('setCartList', result)
          resolve('加入购物车成功')
        })
      } else {
        // 2. 未登录 - 直接修改本地
        store.commit('insertCart', payload)
        resolve('加入购物车成功')
      }
    })
  },
  // 删除购物车商品
  deleteCart (store, skuId) {
    return new Promise(resolve => {
      if (store.rootState.user.profile.token) {
        deleteCart([skuId]).then(() => {
          // 获取最新购物车数据
          return findCart()
        }).then(({ result }) => {
          store.commit('setCartList', result)
          resolve('删除成功')
        })
      } else {
        store.commit('deleteCart', skuId)
        resolve('删除成功')
      }
    })
  },
  // 更新修改购物车商品对象
  updateCart (store, goods) {
    return new Promise(resolve => {
      if (store.rootState.user.profile.token) {
        updateCart(goods).then(() => {
          return findCart()
        }).then(({ result }) => {
          store.commit('setCartList', result)
          resolve('更新成功')
        })
      } else {
        store.commit('updateCart', goods)
        resolve('更新成功')
      }
    })
  },
  // 做有效商品的全选
  checkAllCart (store, selected) {
    return new Promise(resolve => {
      if (store.rootState.user.profile.token) {
        // 1. 已登录 - 发送请求
        const skuIds = store.getters.validList.map(item => item.skuId)
        checkAllCart({ selected, skuIds }).then(() => {
          return findCart()
        }).then(({ result }) => {
          store.commit('setCartList', result)
        })
        resolve()
      } else {
        // 2. 未登录 - 直接修改本地

        store.getters.validList.forEach(item => {
          // 注意这里还不能修改到仓库的数据
          item.selected = selected
          // 调用 commit 才能修改仓库的数据
          store.commit('updateCart', item)
        })
        resolve()
      }
    })
  },
  // 批量删除选中商品
  batchDeleteCart (store, isInvalid) {
    return new Promise(resolve => {
      if (store.rootState.user.profile.token) {
        // 1. 已登录 - 发送请求
        const skuIds = store.getters[isInvalid === true ? 'invalidList' : 'selectedList'].map(item => item.skuId)
        deleteCart(skuIds).then(() => {
        // 获取最新购物车数据
          return findCart()
        }).then(({ result }) => {
          store.commit('setCartList', result)
          resolve('删除成功')
        })
      } else {
        // 2. 未登录 - 直接修改本地
        store.getters[
          isInvalid === true ? 'invalidList' : 'selectedList'
        ].forEach(item => {
          // 调用 commit 才能修改仓库的数据
          store.commit('deleteCart', item.skuId)
        })
        resolve()
      }
    })
  },
  // 修改sku规格函数
  updateCartSku (store, { oldSkuId, newSku }) {
    return new Promise(resolve => {
      if (store.rootState.user.profile.token) {
        // 1. 已登录 - 发送请求
        const oldGoods = store.state.list.find(item => item.skuId === oldSkuId)
        deleteCart([oldSkuId]).then((res) => {
          // 删除操作
          console.log(res)
          // 加入购物车
          return insertCart({ skuId: newSku.skuId, count: oldGoods.count })
        }).then((res) => {
          console.log(res)
          // 更新页面
          return findCart()
        }).then(({ result }) => {
          console.log(result)
          store.commit('setCartList', result)
          resolve()
        })
        resolve()
      } else {
        // 2. 未登录 - 直接修改本地
        // 1. 获取旧的商品信息
        const oldGoods = store.state.list.find(item => item.skuId === oldSkuId)
        console.log(oldGoods)
        // 2. 删除旧的商品
        store.commit('deleteCart', oldSkuId)
        // 3. 合并一条新的商品信息
        const newGoods = { ...oldGoods, ...newSku, stock: newSku.inventory }
        // 4. 新商品信息添加到购物车列表中
        store.commit('insertCart', newGoods)

        resolve()
      }
    })
  },
  // 获取购物车商品信息（确保库存，价格等信息都是最新的）
  findCartList (store) {
    return new Promise((resolve) => {
      if (store.rootState.user.profile.token) {
        // 1. 已登录 - 发送请求
        findCart().then(({ result }) => {
          // console.log(result)
          store.commit('setCartList', result)
        })
      } else {
        // 2. 未登录 - 直接修改本地
        // 查一下购物车列表中所有的商品的最新信息
        store.state.list.map(async item => {
          const { result } = await getNewCartGoods(item.skuId)
          // console.log(result)
          store.commit('updateCart', { skuId: item.skuId, ...result })
        })
        resolve()
      }
    })
  },
  // 合并本地购物车
  async mergeLocalCart (store) {
    // 有效列表中的获取合并时所需参数
    const mergeData = store.getters.validList.map(item => ({
      skuId: item.skuId,
      selected: item.selected,
      count: item.count
    }))

    // 发送合并购物车请求接口
    await mergeCart(mergeData)
    // 合并成功将本地购物车删除
    store.commit('setCartList', [])
  }
}

export default {
  namespaced: true,
  state,
  mutations,
  actions,
  getters
}
